# ************** PROGRAMA Instalador del CONTROLY **************************
#Devuelve 0 si la instalación fue correcta
#Devuelve 1 si la instalación estaba COMPLETA con anterioridad
#Devuelve 2 si la instalación esta INCOMPLETA y el usuario no completo la misma
#Devuelve 3 si el usuario no acepto los terminos y condiciones
#Devuelve 4 si el Perl 5 no esta instalado
#Devuelve 5 si el usuario no confirmo la instalación

# **************** VARIABLES DE ENTORNO CON INICIALIZACION POR DEFECTO *****
GRUPO=$PWD/"grupo06"
CONFDIR=$GRUPO"/conf"
CONFFILE=$CONFDIR"/InstalY.conf"
InstalYLOG=$CONFDIR"/InstalY.log"
BINDIR="bin"
MAEDIR="mae"
ARRIDIR="arribos"
DATASIZE=100
RECHDIR="rechazados"
ACEPDIR="aceptados"
PROCDIR="procesados"
REPODIR="reportes"
LOGDIR="log"
LOGEXT="log"
LOGSIZE=400
ESTADO="LISTA"
CABECERA="TP SO7508 Primer Cuatrimestre 2013. Tema Y Copyright © Grupo 06"

# *************** FUNCIONES *****************
#Funcion que finaliza el programa con codigo de retorno 0
function fin
{
	exit "$1"
}

#Funcion que hace el log
#$1 mensaje
#$2 tipo de error
function log
{
	#echo $(date +"%Y%m%d %T")"-"$(whoami)"-InstalY-"$2"-"$1 >> $InstalYLOG
	./WriteLog.sh "$InstalYLOG" "$2" "$1"
	return 0
}

#Funcion que muestra por pantalla y lo envia al log
function log_show
{
	echo $1
	log "$1" "$2"
	return 0
}

#Funcion que verifica la version de Perl
#Devuelve 0 si la versión del Perl es correcta
#Devuelve 1 si la versión del Perl es incorrecta o no se encuetra perl
function checkPerl
{
	#perl -V:version devuelve -> version='5.14.2';
	#check si tiene Perl 5 con la expresion regular
	if [ $(perl -V:version | grep "='5" -c) -eq 1 ]
 	 then
 	 	#obtengo que version de perl tiene
	 	versionPerl=$(perl -V:version | grep "'5\..*'" -o)
		#verionPerl es del tipo '5.14.2';
		log_show "$CABECERA" "I"
	 	log_show "Perl Version: ${versionPerl}" "I"
	 	return 0
	else
		log_show "$CABECERA" "I"
		log_show "Para instalar el TP es necesario contar con Perl 5 o superior instalado. Efectúe su instalación e intentelo nuevamente."
		log_show "Proceso de Instalación Cancelado" "I"
		return 1
 	fi
}

#Funcion que muestra por pantalla el contenido de las variables del sistema
function mostrar_config
{
	log_show "$CABECERA" "I"
	log_show "Librería del Sistema: $CONFDIR" "I"
	if [ $ESTADO == "COMPLETA" ] || [ $ESTADO == "INCOMPLETA" ]
	 then
	 	#Listar archivos de CONFDIR
	 	log_show "Archivos de $CONFDIR" "I"
	 	log_show "$(ls -1 $CONFDIR)" "I"
	fi
	log_show "Ejecutables: $GRUPO/$BINDIR" "I"
	if [ $ESTADO == "COMPLETA" ] || [ $ESTADO == "INCOMPLETA" ]
	 then
	 	#Listar archivos de BINDIR (si existe)
	 	if [ -d $GRUPO/$BINDIR ] ; then
		 	log_show "Archivos de $GRUPO/$BINDIR" "I"
		 	#ls -1 $GRUPO/$BINDIR
		 	log_show "$(ls -1 $GRUPO/$BINDIR)" "I"
	 	fi
	fi
	log_show "Archivos maestros: $GRUPO/$MAEDIR" "I"
	if [ $ESTADO == "COMPLETA" ] || [ $ESTADO == "INCOMPLETA" ]
	 then
	 	#Listar archivos de MAEDIR (si existe)
	 	if [ -d $GRUPO/$MAEDIR ] ; then
		 	log_show "Archivos de $GRUPO/$MAEDIR" "I"
		 	log_show "$(ls -1 $GRUPO/$MAEDIR)" "I"
		fi
	fi
	log_show "Directorio de arribo de archivos externos: $GRUPO/$ARRIDIR" "I"
	log_show "Espacio mínimo libre para arribos: $DATASIZE Mb" "I"
	log_show "Archivos externos aceptados: $GRUPO/$ACEPDIR" "I"
	log_show "Archivos externos rechazados: $GRUPO/$RECHDIR" "I"
	log_show "Archivos procesados: $GRUPO/$PROCDIR" "I"
	log_show "Reportes de salida: $GRUPO/$REPODIR" "I"
	log_show "Logs de auditoría del Sistema: $GRUPO/$LOGDIR/<comando>.$LOGEXT" "I"
	log_show "Tamaño máximo para los archivos de log del sistema: $LOGSIZE Kb" "I"
	log_show "Estado de la instalación: $ESTADO" "I"
	return 0
}

#Funcion que Crea los directorios y copia los archivos a los mismos
#Devuelve 0 si la instalación finalizo correctamente
#Devuelve 1 si el usuario no confirma la instalación
function confirmar_instalacion
{
	seguir=1
	#Mientras la respuesta sea diferente de Si o de No sigo preguntando
	while [ $seguir -ne 0 ]
	do
	 	log_show "Iniciando Instalación. Esta Ud. seguro? (Si-No)" "I"
		read -r confirma
		log "$confirma" "I"
		if [ "$confirma" == "Si" ]
		 then
		 	seguir=0
		elif [ "$confirma" == "No" ]
		 then
		 	return 1
		else
			seguir=1
		fi
	done
 	#Instalación
 	log_show "Creando Estructuras de directorio . . . ." "I"
 	#Crear estructura BINDIR si no existe ya
 	mkdir -p $GRUPO/$BINDIR
 	log_show "$GRUPO/$BINDIR" "I"
 	mkdir -p $CONFDIR/pid
 	#Crear estructura MAEDIR
 	mkdir -p $GRUPO/$MAEDIR
 	log_show "$GRUPO/$MAEDIR" "I"
 	#Crear estructura ARRIDIR
 	mkdir -p $GRUPO/$ARRIDIR
 	log_show "$GRUPO/$ARRIDIR" "I"
 	#Crear estructura RECHDIR
 	mkdir -p $GRUPO/$RECHDIR
 	log_show "$GRUPO/$RECHDIR" "I"
 	#Crear estructura ACEPDIR
 	mkdir -p $GRUPO/$ACEPDIR
 	log_show "$GRUPO/$ACEPDIR" "I"
 	#Crear estructura PROCDIR
 	mkdir -p $GRUPO/$PROCDIR
 	log_show "$GRUPO/$PROCDIR" "I"
 	#Crear estructura LOGDIR
 	mkdir -p $GRUPO/$LOGDIR
 	log_show "$GRUPO/$LOGDIR" "I"
 	#Crear estructura REPODIR
 	mkdir -p $GRUPO/$REPODIR
 	log_show "$GRUPO/$REPODIR" "I"
 	#Muevo los archivos maestros al directorio MAEDIR
 	log_show "Instalando Archivos Maestros" "I"
 	for f in "instalY_files/mae/*.*"
 	do
 		cp $f "$GRUPO/$MAEDIR/"
 	done
 	#Muevo la tabla de separadores y la tabla de campos al directorio CONFDIR
 	log_show "Instalando Tablas de Configuración" "I"
 	for f in "instalY_files/conf/*.*"
 	do
 		cp $f "$CONFDIR/"
 	done
 	#Muevo los ejecutables y funciones al directorio BINDIR
 	log_show "Instalando Programas y Funciones" "I"
 	for f in "*.sh"
 	do
 		cp $f "$GRUPO/$BINDIR/"
 	done
 	for f in "*.pl"
 	do
 		cp $f "$GRUPO/$BINDIR/"
 	done
 	#Actualizo el archivo de configuración
 	log_show "Actualizando la configuración del sistema" "I"
 	echo "GRUPO=$GRUPO=$(whoami)=$(date)" > $CONFFILE
 	echo "CONFDIR=$CONFDIR=$(whoami)=$(date)" >> $CONFFILE
 	echo "BINDIR=$BINDIR=$(whoami)=$(date)" >> $CONFFILE
 	echo "MAEDIR=$MAEDIR=$(whoami)=$(date)" >> $CONFFILE
 	echo "ARRIDIR=$ARRIDIR=$(whoami)=$(date)" >> $CONFFILE
 	echo "ACEPDIR=$ACEPDIR=$(whoami)=$(date)" >> $CONFFILE
 	echo "RECHDIR=$RECHDIR=$(whoami)=$(date)" >> $CONFFILE
 	echo "PROCDIR=$PROCDIR=$(whoami)=$(date)" >> $CONFFILE
 	echo "REPODIR=$REPODIR=$(whoami)=$(date)" >> $CONFFILE
 	echo "LOGDIR=$LOGDIR=$(whoami)=$(date)" >> $CONFFILE
 	echo "LOGEXT=$LOGEXT=$(whoami)=$(date)" >> $CONFFILE
 	echo "LOGSIZE=$LOGSIZE=$(whoami)=$(date)" >> $CONFFILE
 	echo "DATASIZE=$DATASIZE=$(whoami)=$(date)" >> $CONFFILE
	#Muestro Mensaje de fin de instalación
	log_show "Instalación concluida" "I"
	return 0
}

#Funcion que se fija el estado de la instalación
#Devuelve 0 si fue instalado anteriormente y esta COMPLETA
#Devuelve 1 si se completo la instalación en esta ejecución
#Devuelve 4 si no tiene perl instalado
#Devuelve 5 si no confirmo la instalación
#Devuelve 6 si no encontro el archivo de configuración
function check_install
{
	# Llamada a funcion externa que levanta la configuración y se fija el estado
	. check_state.sh
	state=$?
	if [ $state -eq 2 ]
	 then
	 	#No encontro el archivo de configuración
	 	return 6
	elif [ $state -eq 0 ]
	 then
	 	ESTADO="COMPLETA"
	elif [ $state -eq 1 ]
	 then
		ESTADO="INCOMPLETA"
	fi
	#La instalación se realizo anteriormente
	mostrar_config
	if [ $ESTADO == "COMPLETA" ]
	 then
	 	log_show "Proceso de Instalación Cancelado" "SE"
	 	return 1
	fi
	if [ $ESTADO == "INCOMPLETA" ]
	 then
	 	#LISTAR componentes faltantes
	 	log_show "Componentes faltantes:" "I"
	 	log_show "$LISTA" "I"
	 	seguir=1
		#Mientras la respuesta sea diferente de Si o de No sigo preguntando
		while [ $seguir -ne 0 ]
		do
		 	log_show "Desea completar la instalación? (Si-No)" "I"
			read -r rta
			log "$rta" "I"
			if [ "$rta" == "Si" ]
			 then
			 	seguir=0
			elif [ "$rta" == "No" ]
			 then
			 	return 2
			else
				seguir=1
			fi
		done
		if [ $rta == "Si" ]
		 then
		 	checkPerl
		 	if [ $? -ne 0 ]
		 	 then
			 	 return 4
		 	fi
		 	#Brindo las indicaciones para completar el proceso de Instalación...
		 	ESTADO="LISTA"
		 	mostrar_config
		 	confirmar_instalacion
		 	if [ $? -ne 0 ]
		 	 then
		 	 	return 5
		 	fi
		 	return 0
		fi
	fi
}

#Funcion que valida que lo ingresado sea un directorio valido
function es_dir
{
	#Compruebo que directorio sea un directorio (empieza con letras y luego puede haber o no barras)
	if ! [[ "$1" =~ ^[A-Za-z0-9]{1,}.* ]]
	 then
	 	log_show "Por favor ingrese un directorio o un arbol de directorios, la raiz es $GRUPO/" "E"
	 	return 1
	else
		return 0
	fi
}

#Funcion que valida que el numero ingresado sea positivo y correcto
function es_num_ok
{
	#Compruebo que sea numerico y positivo
	if ! [[ "$1" =~ ^[0-9]+$ ]] ; then
		log_show "Por Favor, Ingrese un número entero y positivo" "E"
		return 1
	else		
	 	return 0
	fi
}

#Verifico el espacio en disco
function hay_espacio
{
	#Obtengo Espacio en disco
#	local esp=$(df -h -BM $GRUPO | awk '{print $4}'| grep "^[0-9].*")
	local esp=$(df -h -BM ${GRUPO} | grep "^/" | awk '{print $4}')
	local espenNum=$(echo "${esp}" | grep "[0-9]*,*[0-9]*" -o)
	local nece=$(echo "${espenNum} - ${1}" | bc)

	if [ ${nece} -gt 0 ]
	 then
		return 0
	else
		log_show "Insuficiente espacio en disco." "E"
		log_show "Espacio disponible ${espenNum} Mb" "E"
		log_show "Espacio requerido ${DATASIZET} Mb" "E"
		log_show "Cancele la instalación e inténtelo mas tarde o vuelva a interntarlo con otro valor." "E"
		return 1
	fi
}

#Funcion que ve si es una extension valida
function check_extension
{
	if ! [[ "$1" =~ ^[a-zA-Z]+$ ]] ; then
		log_show "$1 no es valido como extensión de archivo" "E"
		log_show "Por Favor, Ingrese caracteres entre a y z o entre A y Z unicamente" "E"
		return 1
	else		
	 	return 0
	fi
}
#Función que se encarga de ver si ya se establecio ese directorio para otra variable
function contiene 
{
    local n=$#
    local value=${!n}
    for ((i=1;i < $#;i++))
    do
        if [ "${!i}" == "${value}" ]
         then
            log_show "Ya se establecio el directorio $value para otra funcionalidad" "E"
            return 1
        fi
    done
    return 0
}

#Funcion que se encarga de preguntar por cada variable y guardar las respuestas
function definir_variables
{
	#Defino el directorio de instalación de los ejecutables
	seguir=1
	log_show "Para los directorios que ingrese a continuación la raiz es $GRUPO"
	log_show "Si desea que el directorio, el tamaño o la extensión sean igual a los que se sugieren presione ENTER cuando le pregunte"
	while [ $seguir -ne 0 ]
	do
 		log_show "Defina el directorio de instalación de los ejecutables ($BINDIR)" "I"
 		read -r BINDIRT
	 	log "$BINDIRT" "I"
	 	if [ "$BINDIRT" == "" ]
	 	 then
	 	  BINDIRT=$BINDIR
	 	  break;
	 	fi
	 	es_dir "$BINDIRT"
	 	seguir=$?
 	done
 	BINDIR="$BINDIRT"
 	avars=("$BINDIR")
 	#Defino el directorio de instalación de los archivos maestros
 	seguir=1
	while [ $seguir -ne 0 ]
	do
 		log_show "Defina el directorio de instalación de los archivos maestros ($MAEDIR)" "I"
 		read -r MAEDIRT
 		log "$MAEDIRT" "I"
 		if [ "$MAEDIRT" == "" ]
	 	 then
	 	  MAEDIRT=$MAEDIR
	 	  break;
	 	fi
 		es_dir "$MAEDIRT"
 		seguir=$?
 		if [ $seguir -eq 0 ]
 		 then
 		 	contiene "${avars[@]}" "$MAEDIRT"
 		 	seguir=$?
 		fi
 	done
 	MAEDIR="$MAEDIRT"
 	avars=("$BINDIR" "$MAEDIR")
	#Defino el directorio de arribo de archivos externos
	seguir=1
	while [ $seguir -ne 0 ]
	do
		log_show "Defina el directorio de arribo de archivos externos ($ARRIDIR)" "I"
		read -r ARRIDIRT	  	
	  	log "$ARRIDIRT" "I"
	  	if [ "$ARRIDIRT" == "" ]
	 	 then
	 	  ARRIDIRT=$ARRIDIR
	 	  break;
	 	fi
	  	es_dir "$ARRIDIRT"
	  	seguir=$?
	  	if [ $seguir -eq 0 ]
 		 then
 		 	contiene "${avars[@]}" "$ARRIDIRT"
 		 	seguir=$?
 		fi
	done
	ARRIDIR="$ARRIDIRT"
	avars=("$BINDIR" "$MAEDIR" "$ARRIDIR")
	#Defino el espacio mínimo libre para el arribo de archivos externos
	seguir=1
	while [ $seguir -ne 0 ]
	do
		log_show "Defina el espacio mínimo libre para el arribo de archivos externos en Mbytes ($DATASIZE)" "I"
		read -r DATASIZET
		if [ "$DATASIZET" == "" ]
	 	 then
	 	  DATASIZET=$DATASIZE
	 	  break;
	 	fi
		log "$DATASIZET" "I"
		es_num_ok "$DATASIZET"
		if [ $? -eq 0 ]
		 then
		 hay_espacio $DATASIZET
		 seguir=$?
		fi
	done 
	DATASIZE=$DATASIZET
	#Defino el directorio de grabación de los archivos rechazados
	seguir=1
	while [ $seguir -ne 0 ]
	do
		log_show "Defina el directorio de grabacíon de archivos externos rechazados ($RECHDIR)" "I"
		read -r RECHDIRT
	 	log "$RECHDIRT" "I"
	 	if [ "$RECHDIRT" == "" ]
	 	 then
	 	  RECHDIRT=$RECHDIR
	 	  break;
	 	fi
	 	es_dir "$RECHDIRT"
	 	seguir=$?
	 	if [ $seguir -eq 0 ]
 		 then
 		 	contiene "${avars[@]}" "$RECHDIRT"
 		 	seguir=$?
 		fi
 	done
 	RECHDIR="$RECHDIRT"
 	avars=("$BINDIR" "$MAEDIR" "$ARRIDIR" "$RECHDIR")
	#Defino el directorio de grabación de los archivos aceptados
	seguir=1
	while [ $seguir -ne 0 ]
	do
		log_show "Defina el directorio de grabación de archivos externos aceptados ($ACEPDIR)" "I"
		read -r ACEPDIRT
	 	log "$ACEPDIRT" "I"
	 	if [ "$ACEPDIRT" == "" ]
	 	 then
	 	  ACEPDIRT=$ACEPDIR
	 	  break;
	 	fi
	 	es_dir "$ACEPDIRT"
	 	seguir=$?
	 	if [ $seguir -eq 0 ]
 		 then
 		 	contiene "${avars[@]}" "$ACEPDIRT"
 		 	seguir=$?
 		fi
 	done
 	ACEPDIR="$ACEPDIRT"
 	avars=("$BINDIR" "$MAEDIR" "$ARRIDIR" "$RECHDIR" "$ACEPDIR")
 	#Defino el directorio de grabación de archivos procesados
 	seguir=1
	while [ $seguir -ne 0 ]
	do
		log_show "Defina el directorio de grabación de archivos procesados ($PROCDIR)" "I"
		read -r PROCDIRT
	 	log "$PROCDIRT" "I"
	 	if [ "$PROCDIRT" == "" ]
	 	 then
	 	  PROCDIRT=$PROCDIR
	 	  break;
	 	fi
	 	es_dir "$PROCDIRT"
	 	seguir=$?
	 	if [ $seguir -eq 0 ]
 		 then
 		 	contiene "${avars[@]}" "$PROCDIRT"
 		 	seguir=$?
 		fi
 	done
 	PROCDIR="$PROCDIRT"
 	avars=("$BINDIR" "$MAEDIR" "$ARRIDIR" "$RECHDIR" "$ACEPDIR" "$PROCDIR")
	#Defino el directorio de grabación de los reportes de salida
	seguir=1
	while [ $seguir -ne 0 ]
	do
		log_show "Defina el directorio de grabación de los reportes de salida ($REPODIR)" "I"
		read -r REPODIRT
	 	log "$REPODIRT" "I"
	 	if [ "$REPODIRT" == "" ]
	 	 then
	 	  REPODIRT=$REPODIR
	 	  break;
	 	fi
	 	es_dir "$REPODIRT"
	 	seguir=$?
	 	if [ $seguir -eq 0 ]
 		 then
 		 	contiene "${avars[@]}" "$REPODIRT"
 		 	seguir=$?
 		fi
 	done
 	REPODIR="$REPODIRT"
 	avars=("$BINDIR" "$MAEDIR" "$ARRIDIR" "$RECHDIR" "$ACEPDIR" "$PROCDIR" "$REPODIR")
	#Defino el directorio de logs para los comandos
	seguir=1
	while [ $seguir -ne 0 ]
	do
		log_show "Defina el directorio de logs ($LOGDIR)" "I"
		read -r LOGDIRT
	 	log "$LOGDIRT" "I"
	 	if [ "$LOGDIRT" == "" ]
	 	 then
	 	  LOGDIRT=$LOGDIR
	 	  break;
	 	fi
	 	es_dir "$LOGDIRT"
	 	seguir=$?
	 	if [ $seguir -eq 0 ]
 		 then
 		 	contiene "${avars[@]}" "$LOGDIRT"
 		 	seguir=$?
 		fi
 	done
 	LOGDIR="$LOGDIRT"
 	avars=("$BINDIR" "$MAEDIR" "$ARRIDIR" "$RECHDIR" "$ACEPDIR" "$PROCDIR" "$REPODIR" "$LOGDIR")
 	seguir=1
	#Defino la extensión para los archivos de log
	while [ $seguir -ne 0 ]
	do
		log_show "Ingrese la extensión para los archivos de log: ($LOGEXT)" "I"
		read -r LOGEXTT
		log "$LOGEXTT" "I"
		if [ "$LOGEXTT" == "" ]
	 	 then
	 	  LOGEXTT=$LOGEXT
	 	  break;
	 	fi
		check_extension "$LOGEXTT"
		seguir=$?
	done
	LOGEXT=$LOGEXTT
	#Defino el tamaño máximo para los archivos de log
	seguir=1
	while [ $seguir -ne 0 ]
	do
		log_show "Defina el tamaño máximo para los archivos $LOGEXT en Kbytes ($LOGSIZE)" "I"
		read -r LOGSIZET
		log "$LOGSIZET" "I"
		if [ "$LOGSIZET" == "" ]
	 	 then
	 	  LOGSIZET=$LOGSIZE
	 	  break;
	 	fi
		es_num_ok "$LOGSIZET"
		seguir=$?
	done 
	LOGSIZE=$LOGSIZET
}

#Funcion que muestra los terminos y condiciones y pregunta si los acepta
#Al No aceptar los finaliza el programa de instalación
#Si los acepta vuelve a la instalación
function terminos_y_condiciones
{
	#Aceptación de Términos y condiciones
 	log_show "$CABECERA" "I"
	log_show "ATENCION:Al instalar TP SO7508 Primer Cuatrimestre 2013 UD: expresa aceptar los términos y Condiciones del \"ACUERDO DE LICENCIA DE SOFTWARE\" incluido en este paquete." "I"
	seguir=1
	#Mientras la respuesta sea diferente de Si o de No sigo preguntando
	while [ $seguir -ne 0 ]
	do
		log_show "Acepta? Si - No" "I"
		read -r rta
		log "$rta" "I"
		if [ "$rta" == "Si" ]
		 then
		 	seguir=0
		elif [ "$rta" == "No" ]
		 then
		 	seguir=0
		else
			seguir=1
		fi
	done
	if [ $rta == "No" ]
	 then
		#No acepto los terminos y condiciones, entonces finalizo el proceso
		return 1
	fi
	return 0
}

# ************ FIN FUNCIONES ****************

# ************ INICIO PRINCIPAL *************

clear
#Crear carpeta de configuración??
	mkdir -p $GRUPO
	mkdir -p $CONFDIR
#Inicializar Archivo de Log
	#Veo si existe un archivo de log, si no existe lo creo
	if [ ! -f $InstalYLOG ] 
	 then	
	 	#Creo archivo de log de la instalación
	 	echo "Creando archivo de Log de la Instalación" "I"
	 	touch "$InstalYLOG"
	fi	
	#Muestro mensaje de Inicio de Ejecución
	log_show "Inicio de Ejecución" "I"
	log_show "Log del Comando InstalY: $InstalYLOG" "I"
	log_show "Directorio de Configuración: $CONFDIR" "I"
	#Llamo a la funcion que indica el estado de la instalación
	check_install
	seguir=$?
	if [ $seguir -ne 6 ]
	 then
	 	#El programa InstalY ya fue ejecutado previamente
	 	fin $seguir
	fi
 	#No se instalo previamente
 	terminos_y_condiciones
 	if [ $? -ne 0 ]
 	 then
 	 	fin 3
 	fi
	#Acepto los terminos y condiciones, Chequeo que Perl esté instalado
	checkPerl
	if [ $? -ne 0 ]
	 then
	 	#No esta instalado Perl finalizo la instalación
	 	fin 4
	fi
 	seguir=0
 	while [ $seguir -ne 1 ]
 	do
	 	definir_variables
		#Muestro estructura de directorios resultante y valores de parámetros configurados
		clear
		mostrar_config
		#Confirmo Inicio de Instalación
		seguir=3
		#Mientras la respuesta sea diferente de Si o de No sigo preguntando
		while [ $seguir -gt 2 ]
		do
			log_show "La Información es correcta? Si-No" "I"
			read -r confirma
			log "$confirma" "I"
			if [ "$confirma" == "Si" ]
			 then
			 	seguir=1
			elif [ "$confirma" == "No" ]
			 then
			 	seguir=2
			else
				seguir=3
			fi
		done
	done
	#Solo sale del while si dio Si
	confirmar_instalacion
	if [ $? -ne 0 ]
	 then
	 	fin 5
	fi
# ************ FIN PRINCIPAL *************
